package com.mgkj.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mgkj.base.HttpResult;
import com.mgkj.base.context.BaseContext;
import com.mgkj.common.result.Result;
import com.mgkj.common.utils.TimeUtils;

import com.mgkj.common.utils.HttpClientUtil;
import com.mgkj.dto.KWAndNum;
import com.mgkj.dto.MOCTGDto;
import com.mgkj.dto.yf.LldDto;
import com.mgkj.dto.yf.LldList;
import com.mgkj.dto.yf.MOCTCchaDto;
import com.mgkj.dto.yf.MOCTEDto;
import com.mgkj.entity.*;
import com.mgkj.entity.yf.*;
import com.mgkj.mapper.*;
import com.mgkj.service.MaterialRequisitionService;
import com.mgkj.vo.yf.MocteupdateVo;
import com.mgkj.base.context.BaseContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: LiangPanDeng
 * @Date: 2024/03/12/13:31
 * @Description:
 */
@Service
public class MaterialRequisitionServiceImpl implements MaterialRequisitionService {
    @Resource
    private InitAdmmfMapper admmfMapper;

    @Resource
    private WmsInvmlMapper wmsInvmlMapper;

    @Resource
    private WmsInvlaMapper wmsInvlaMapper;

//    @Autowired
//    private MaterialRequisitionServiceImpl self;

    @Resource
    private InitCmsmdMapper cmsmdMapper;

    @Resource
    private MoctaMapper moctaMapper;

    @Resource
    private InitMoctbMapper moctbMapper;

    @Resource
    private InitMoctcMapper moctcMapper;

    @Resource
    private InitMocteMapper mocteMapper;

    @Resource
    private InitCmsmqMapper cmsmqMapper;

    @Resource
    private InvmbMapper invmbMapper;

    @Resource
    private InvmcMapper invmcMapper;

    @Resource
    private CommonMapper commonMapper;


    @Override
    public Result add(LldDto lldDto) {
        int flage = 0;

        // 领料单创建人
        String company = lldDto.getCompany();
        String creator = lldDto.getCreator();
        InitAdmmf admmf = admmfMapper.selectOne(new QueryWrapper<InitAdmmf>().eq("MF001", creator));
        String userGroup = admmf.getMF004();

        // 领料日期
        String rq = lldDto.getRq();
        // 工厂编号
        String gcbh = lldDto.getGcbh();
        //  工作中心
        String gzzx = lldDto.getGzzx();
        //  领料单单别
        String lld = lldDto.getDb();
        // 领料工单列表
        List<LldList> list = lldDto.getList();

        // 1.判断领料单是否合规

        // 2.判断工单是否合规
        String errorMsg =  null ;

        System.out.println("123");
        if (errorMsg != null) {
            System.out.println(errorMsg);
            return Result.fail(errorMsg).message(errorMsg);
        }

        // 3.领料单单身信息创建
        InitMoctc moctc = new InitMoctc();
        String nowTime  = TimeUtils.getNowTime();
        // 设置创建者
        moctc.setCompany(company);
        moctc.setCreator(creator);
        moctc.setUsrGroup(userGroup);
        moctc.setCreateDate(nowTime);
        moctc.setModiDate("");
        moctc.setModifier("");
        moctc.setFlag((double) (2));

        // 获取领料单单别 对应的信息
        Cmsmq cmsmq = cmsmqMapper.selectOne(new QueryWrapper<Cmsmq>().eq("MQ001",lld));

        // 领料单对应的年位数
        int yearLength = cmsmq.getMq005().intValue();
        // 获取根据单别获取单号
        String tc002 = null;
        if (yearLength == 4) tc002 = moctcMapper.getNewTc002Year4(lld);
        else tc002 = moctcMapper.getNewTc002Year2(lld);

        moctc.setTc001(lld);
        moctc.setTc002(tc002);
        moctc.setTc003(rq);
        moctc.setTc004(gcbh);
        moctc.setTc005(gzzx);
        moctc.setTc006("");
        moctc.setTc007("");
        moctc.setTc008("5");
        // 设置审核码
        moctc.setTc009("N");
        // 设置打印次数
        moctc.setTc010((double) 0);
        // 设置生成分录-成本  Y/N
        moctc.setTc011("N");
        // 设置 生成排序 1.按工单单号、2.按材料品号
        moctc.setTc012("1");
        // 取数方式 Y.需领用量、N.与库存量比较
        moctc.setTc013("Y");
        // 设置  单据日期 过来的
        moctc.setTc014(rq);
        // 设置审核者
        moctc.setTc015("");
        // 签核状态码 0.待处理、S.传送中、1.签核中、2.退件、3.已核准、4.撤销审核中、5.作废中、
        // 6.取消作废中、N.不运行电子签核[DEF:"N"]
        moctc.setTc016("N");
        // 设置 传送次数
        moctc.setTc017((double) 0);
        //   来源别 0.自行输入、1.工单、2.生产入库自动扣料、3.委外进自动扣料、4.委外退自动扣料、
        // 5.开工单、6.委外进厂供料自动扣料、7.委外退厂供料自动扣料 8.批次发料自动退料[DEF:"0"]
        moctc.setTc018("0");
        // 设置   来源单别
        //moctc.setTC019(db);
        // 设置 来源单号
        //moctc.setTC020(dh);
        //moctcMapper.add(moctc);
        // 设置 部门
        // 根据工作中心编号获取 工作中心
        InitCmsmd cmsmd = cmsmdMapper.selectOne(new QueryWrapper<InitCmsmd>().eq("MD001",gzzx));
        if (cmsmd==null){
            moctc.setTc021("");
        }else {
            moctc.setTc021(cmsmd.getMd015().trim());
        }
        // 设置人员编号
        moctc.setTc028("");
        moctc.setTc031("");
        //log.info("moctc :" + moctc.toString());

        //添加领料单单身

        List<InitMocte> moctes = new ArrayList<>();
        int xh = 1;
        double count = 0;
        //遍历后经过查询后set，领料单身的序号和单别单号以便wms插入两表用
        for (LldList lllist : list) {
            // 判断该物料是否领取完成

            //   判断是否存在该物料
            InitMoctb moctb = moctbMapper.selectOne(new QueryWrapper<InitMoctb>().eq("TB001", lllist.getGddb())
                    .eq("TB002", lllist.getGddh())
                    .eq("TB003", lllist.getWlbh()));
            if (moctb == null) {
                if (errorMsg == null )
                    errorMsg = "工单单别为: " + lllist.getGddb() +"，  工单单号为"+ lllist.getGddh() + "的工单中, 没有物料编号为：" + lllist.getWlbh() +  "物料信息";
                else errorMsg = "\n" + errorMsg;

                continue;
            }

            // 存在查看库存数量和要领的数量 需要获取工单单身每个物料的仓库
            //物料对应的仓库编号
            String tb009 = moctb.getTb009();
            //工艺
            String tb006 = moctb.getTb006();
            QueryWrapper<Invmc> invmcQueryWrapper = new QueryWrapper<>();
            invmcQueryWrapper.eq("MC001",lllist.getWlbh()).eq("MC002",tb009);
            Invmc invmc = invmcMapper.selectOne(invmcQueryWrapper);
            Double mc007 = new Double(0);
            // 获取库存数量
            if (invmc != null)
                mc007 = invmc.getMc007();
            if (mc007 < lllist.getQtw()){
                if (errorMsg != null)
                    errorMsg  +=
                            "/n" + "工单单别为 ：" + lllist.getGddb() + "，单号为：" + lllist.getGddh() + "，中的需要领料的单号为：" + lllist.getWlbh() +"，的产品在仓库中的数量不足!" ;
                else
                    errorMsg  =
                            "工单单别为 ：" + lllist.getGddb() + "，单号为：" + lllist.getGddh() + "，中的需要领料的单号为：" + lllist.getWlbh() +"，的产品在仓库中的数量不足!" ;

                //log.info(errorMsg);
                flage =3;
                continue;
            }

            // errorMsg 不为空说明 存在库问题 不用在列表中添加
            if (errorMsg != null && flage == 3)
                continue;

            // 仓库库存满足  设置领料单单身
            count += lllist.getQtw();
            InitMocte mocte = new InitMocte();
            mocte.setCompany(moctb.getCompany().trim());
            mocte.setCreator(creator);
            mocte.setUsrGroup(userGroup);
            mocte.setCreateDate(nowTime);
            mocte.setFlag((double) 2);
            mocte.setTe001(lld);
            mocte.setTe002(tc002);
            mocte.setTe003(String.format("%04d", xh));
            xh++;
            // 物料品号
            mocte.setTe004(lllist.getWlbh());
            // 领料数量
            mocte.setTe005(lllist.getQtw());
            // 单位
            mocte.setTe006(moctb.getTb007().trim());
            // 参考单位
            mocte.setTe007("");
            // 仓库
            mocte.setTe008(tb009);
            // 工艺
            mocte.setTe009(tb006);
            //批号-前端筛选传
            mocte.setTe010(lllist.getLotNumber());
            // 工单单别 单号
            mocte.setTe011(lllist.getGddb());
            mocte.setTe012(lllist.getGddh());
            // 设置领料说明
            mocte.setTe013("可用量: " + Math.round(mc007));
            // 备注
            mocte.setTe014(lllist.getRemark());
            mocte.setTe015("");
            // 材料类型
            mocte.setTe016(moctb.getTb011());

            mocte.setTe017(moctb.getTb012().trim());
            // 设置材料规格
            mocte.setTe018(moctb.getTb013().trim());
            // 设置审核码
            mocte.setTe019("N");
            // 设置项目编号
            //mocte.setTE020(moctb.getTB038().trim());
            //mocte.setTE020("********************");
            mocte.setTe020("");
            // 设置领退料包装数量
            mocte.setTe021(0.00);
            // 包装单位
            mocte.setTe022("");
            // 设置批号设置 说明
            mocte.setTe023("");
            // 设置折算率
            mocte.setTe024(0.00);
            // 设置库位-前端筛选传：易飞统一#
            mocte.setTe025("##########");
            // 设置库存单位
            Invmb invmb = invmbMapper.selectOne(new QueryWrapper<Invmb>().eq("MB001",lllist.getWlbh()));
            mocte.setTe026(invmb.getMb004().trim());

            // 设置领料库存数量
            mocte.setTe027(mocte.getTe005());

            mocte.setUdf01(invmb.getUdf01());

            // 设置 类型 1.工程品号 2.正式品号[DEF:"2"]
            mocte.setTec01("2");
            // 设置 核建确认  Y/N[DEF:"N"]
            mocte.setTeh01("N");
            moctes.add(mocte);
            lllist.setLldb(mocte.getTe001());
            lllist.setLldh(mocte.getTe002());
            lllist.setXh(mocte.getTe003());
            lllist.setCreator(creator);
            lllist.setUserGroup(userGroup);
            lllist.setCompany(company);
            //log.info(mocte.toString());

        }

        if (errorMsg != null)
            return Result.fail(errorMsg).message(errorMsg);

        // 设置领料单的领料单头  数量
        moctc.setTc029(count);
        //先删除 单头单身
        moctcMapper.delete(new QueryWrapper<InitMoctc>().eq("TC001",lld).eq("TC002",tc002));
        mocteMapper.delete(new QueryWrapper<InitMocte>().eq("TE001",lld).eq("TE002",tc002));
        // 添加 单头单身
        moctcMapper.insert(moctc);
        for (InitMocte mocte : moctes) {
            mocteMapper.insert(mocte);
        }
        // 判断审核源是否打开
        ShenHe shenHe = new ShenHe();
        //shenHe.setCom(moctc.getCompany());
        shenHe.setCom(company);
        shenHe.setProgram("MOCI03");
        shenHe.setDb(lld);
        shenHe.setDh(moctc.getTc002());
        shenHe.setRq(nowTime.substring(0,8));
        shenHe.setType("DO");
        shenHe.setUser(creator);

        //String url = "http://" + RunHttp.getIp() + ":9000/api/yifei/audit";
//        String url = "http://" + "1dd818cb.r32.cpolar.top" + "/api/yifei/audit";
        String url = "http://" + "192.168.0.141" + ":9000/api/yifei/audit";
        String jsonString = JSON.toJSONString(shenHe);
        System.out.println(jsonString);
        String ans = null;
        try {
            System.out.println("11111");
            System.out.println(url);
            System.out.println(jsonString);
            ans = HttpClientUtil.postRequest(url, jsonString);
            System.out.println("22222");

        }catch (IOException e){
//            moctcMapper.delete(new QueryWrapper<InitMoctc>().eq("TC001",lld).eq("TC002",tc002));
//            mocteMapper.delete(new QueryWrapper<InitMocte>().eq("TE001",lld).eq("TE002",tc002));
            //System.out.println("出现异常请查看审批后台是否开启");
            //log.info("出现异常请查看审批后台是否开启");
            System.out.println(e);
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return Result.fail().message(e.toString());
        }
        new HttpResult();
        HttpResult httpResult;
        if (ans == null){
//            moctcMapper.delete(new QueryWrapper<InitMoctc>().eq("TC001",lld).eq("TC002",tc002));
//            mocteMapper.delete(new QueryWrapper<InitMocte>().eq("TE001",lld).eq("TE002",tc002));
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return Result.fail().message("出现异常请查看审批后台是否开启");
        }
        else {
            System.out.println(ans);
            ans = ans.replace("\\r","");
            System.out.println("ans :"  + ans);
            httpResult = JSON.parseObject(ans,HttpResult.class);
            System.out.println("httpResult: " + httpResult);
            //System.out.println(httpResult.toString());
        }
        if (httpResult.getStatus().equals("失败")){
            //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            moctcMapper.delete(new QueryWrapper<InitMoctc>().eq("TC001",lld).eq("TC002",tc002));
            mocteMapper.delete(new QueryWrapper<InitMocte>().eq("TE001",lld).eq("TE002",tc002));
            return Result.fail(httpResult).message("审核失败！\\n" + "原因：" + httpResult.getReason() + "\\n 详情：" + httpResult.getDetail());
        }
        //审核成功后，更新wms两表
        Boolean b=this.wmsinsertmocte2(list);
        if (!b) {
            moctcMapper.delete(new QueryWrapper<InitMoctc>().eq("TC001",lld).eq("TC002",tc002));
            mocteMapper.delete(new QueryWrapper<InitMocte>().eq("TE001",lld).eq("TE002",tc002));

            return Result.fail().message("wms_invla和wms_invml插入失败！");
        }


//        Result result =  Result.ok();
//        result.setData(lld + "-" + tc002).;

        return Result.ok("领料单创建成功！单号：" + lld + "-" + tc002).message("领料单创建成功！");
    }



    //阿波罗基础上转为易飞，易飞审核之后再更新wms
    @Transactional
    public Boolean wmsinsertmocte2(List<LldList> moctes){
        List<WmsInvml> invmlList=new ArrayList<>();
        List<WmsInvla> wmsInvlas=new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();
        // 定义日期时间格式
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
        // 将 LocalDateTime 对象格式化为字符串
        String formattedDateTime = now.format(formatter2);
        boolean result = true;
        for (LldList mocte : moctes){
            //库位可以不存在
            if (mocte.getKwInfo() == null || mocte.getKwInfo().isEmpty()) {
                result = insertByKw(now,formattedDateTime,mocte,invmlList,wmsInvlas);
            } else {
                for (KWAndNum kwAndNum : mocte.getKwInfo()) {
                    mocte.setBinCode(kwAndNum.getKw());
                    mocte.setQtw(kwAndNum.getNum());
                    result = insertByKw(now,formattedDateTime,mocte,invmlList,wmsInvlas);
                    if (!result) return result;
                }
            }
            if (!result) return result;
        }
        return true;
    }




    @Override
//    @DSTransactional
    public Result updatemoctc(List<MOCTCchaDto> moctCchaDtos) {
        StringBuffer resResult = new StringBuffer();
        String creator = moctCchaDtos.get(0).getCreateBy();
        //遍历单头
        for (MOCTCchaDto moctCchaDto:moctCchaDtos){
            MocteupdateVo mocteupdateVo=new MocteupdateVo();
            List<InitMocte> mocteList=mocteMapper.selectList(new QueryWrapper<InitMocte>()
                    .eq("TE001",moctCchaDto.getTc001())
                    .eq("TE002",moctCchaDto.getTc002()));
            List<InitMocte> llll=mocteMapper.selectList(new QueryWrapper<InitMocte>()
                    .eq("TE001",moctCchaDto.getTc001())
                    .eq("TE002",moctCchaDto.getTc002()));
            int t=0;
            for (InitMocte mocte:llll){
                mocte.setTe005(0.0);//领退料数量
                mocte.setTe027(0.0);//领料库存数量
                t=t+mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
                        .eq("TE001",mocte.getTe001())
                        .eq("TE002",mocte.getTe002())
                        .eq("TE003",mocte.getTe003()));
            }
            System.out.println("这里是执行插入前先把原本的领料单的数量先全部变成0，成功的条数："+t+"。数据库里面的单身总量有："+mocteList.size()+"。");
            List<MOCTEDto> mocteDtoList=moctCchaDto.getMocteDtos();
            List<MOCTEDto> mocteDtoList1=new ArrayList<>();
            List<InitMocte> mocteList1=new ArrayList<>();
            Map<String,Double> map=new HashMap<>();
            // 合并相同 te003 的 te005 值到 map 中
            for (MOCTEDto mocteDto : mocteDtoList) {
                InitMocte mocte=mocteMapper.selectOne(new QueryWrapper<InitMocte>()
                        .eq("TE001",moctCchaDto.getTc001())
                        .eq("TE002",moctCchaDto.getTc002())
                        .eq("TE003",mocteDto.getTe003()));
                mocte.setTe005(mocteDto.getTe005());//前端给的数量
                mocte.setTe025(mocteDto.getTe025());//库位
                mocte.setKwInfo(mocteDto.getKwInfo());
                mocteList1.add(mocte);//这里相当于把前端给我的所有的单身其他值赋上便于后面插入la和ml俩表
                map.compute(mocteDto.getTe003(), (k, existingQuantity) -> {
                    if (existingQuantity == null) {
                        return mocteDto.getTe005();
                    } else {
                        return existingQuantity + mocteDto.getTe005();
                    }
                });
            }
            // 将 map 中的结果转换回 MOCTEDto 对象并添加到 mocteDtoList1 中
            for (Map.Entry<String, Double> entry : map.entrySet()) {
                String te003 = entry.getKey();
                double te005 = entry.getValue();
                MOCTEDto newDto = new MOCTEDto();
                newDto.setTe003(te003);
                newDto.setTe005(te005);
                mocteDtoList1.add(newDto);
            }
            for (MOCTEDto mocteDto:mocteDtoList1){
                InitMocte mocte=mocteMapper.selectOne(new QueryWrapper<InitMocte>()
                        .eq("TE001",moctCchaDto.getTc001())
                        .eq("TE002",moctCchaDto.getTc002())
                        .eq("TE003",mocteDto.getTe003()));//先获取对应序列的单身
                mocte.setTe005(mocteDto.getTe005());//把修改的数量放进去
                mocte.setTe027(mocteDto.getTe005());//库存数量要和领料数量保持一致
//                mocte.setCreator(creator);
//                mocte.setUsrGroup(commonMapper.getUsrGroup(creator));
//                mocte.setTe025(mocteDto.getTe025());//把扫描的库位放进去
//                mocte.setTe019("Y");//修改一下
//                mocte.setUdf12("Y");//这里主要是标记一下这单已经被修改过了
                mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
                        .eq("TE001",moctCchaDto.getTc001())
                        .eq("TE002",moctCchaDto.getTc002())
                        .eq("TE003",mocteDto.getTe003()));//就是更新
            }
            InitMoctc moctc=moctcMapper.selectOne(new QueryWrapper<InitMoctc>()
                    .eq("TC001",moctCchaDto.getTc001())
                    .eq("TC002",moctCchaDto.getTc002()));
//            moctc.setCreator(creator);
//            moctc.setUsrGroup(commonMapper.getUsrGroup(creator));
//            moctcMapper.update(moctc,new QueryWrapper<InitMoctc>()
//                    .eq("TC001",moctCchaDto.getTc001())
//                    .eq("TC002",moctCchaDto.getTc002()));

//            mocteMapper.updategan(moctCchaDto.getTc001(),moctCchaDto.getTc002());

//            Dscma dscma= BaseContext.getCurrentUser();
            String nowTime = TimeUtils.getNowTime();
            // 判断审核源是否打开
            ShenHe shenHe = new ShenHe();
            //shenHe.setCom(moctc.getCompany());
            shenHe.setCom("ZJQH");
            shenHe.setProgram("MOCI03");
            shenHe.setDb(moctCchaDto.getTc001());
            shenHe.setDh(moctCchaDto.getTc002());
            shenHe.setRq(nowTime.substring(0,8));
            shenHe.setType("DO");
//            shenHe.setUser(dscma.getMa001());
            shenHe.setUser(creator);

            //String url = "http://" + RunHttp.getIp() + ":9000/api/yifei/audit";
//            String url = "http://" + "192.168.0.141" + ":9000/api/yifei/audit";
            String url = "http://" + "53aa0bff.r37.cpolar.top" + "/api/yifei/audit";
            String jsonString = JSON.toJSONString(shenHe);

            String ans = null;
            try {
                System.out.println("-------这里是请求的json值"+jsonString);
                ans = HttpClientUtil.postRequest(url, jsonString);
            }catch (Exception e){
                for (InitMocte mocte:mocteList){
                    mocte.setUdf12("N");
                    mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
                            .eq("TE001",mocte.getTe001())
                            .eq("TE002",mocte.getTe002())
                            .eq("TE003",mocte.getTe003()));
                }//这里就是相当于我人为回调数据库
                mocteupdateVo.setCode(201);
                mocteupdateVo.setData(moctCchaDto.getTc001()+"-"+moctCchaDto.getTc002());
                mocteupdateVo.setMsg("失败：连接自动审核发送异常，异常信息如下："+e.toString());
                resResult.append(mocteupdateVo.getMsg() + " " + mocteupdateVo.getData());
                continue;
            }
            HttpResult httpResult;
            if (ans == null){
                for (InitMocte mocte:mocteList){
                    mocte.setUdf12("N");
                    mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
                            .eq("TE001",mocte.getTe001())
                            .eq("TE002",mocte.getTe002())
                            .eq("TE003",mocte.getTe003()));
                }//这里就是相当于我人为回调数据库
                mocteupdateVo.setCode(201);
                mocteupdateVo.setData(moctCchaDto.getTc001()+"-"+moctCchaDto.getTc002());
                mocteupdateVo.setMsg("失败：出现异常请查看审批后台是否开启！");
                resResult.append(mocteupdateVo.getMsg() + " " + mocteupdateVo.getData());
                continue;
            } else {
                ans = ans.replace("\\r","");
                httpResult = JSON.parseObject(ans,HttpResult.class);
                System.out.println("这里是响应结果的json数据: " + httpResult);
            }
            if (httpResult.getStatus().equals("失败")){
                for (InitMocte mocte:mocteList){
                    mocte.setUdf12("N");
                    mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
                            .eq("TE001",mocte.getTe001())
                            .eq("TE002",mocte.getTe002())
                            .eq("TE003",mocte.getTe003()));
                }//这里就是相当于我人为回调数据库
                mocteupdateVo.setCode(201);
                mocteupdateVo.setData(moctCchaDto.getTc001()+"-"+moctCchaDto.getTc002());
                mocteupdateVo.setMsg("审核失败！\\n" + "原因：" + httpResult.getReason() + "\\n 详情：" + httpResult.getDetail());
                resResult.append(mocteupdateVo.getMsg() + " " + mocteupdateVo.getData());
                continue;
            }
//            Boolean b=this.wmsinsertmocte(mocteList1,moctc.getTc008());
//            if (!b){
//                for (InitMocte mocte:mocteList){
//                    mocte.setUdf12("N");
//                    mocteMapper.update(mocte,new QueryWrapper<InitMocte>()
//                            .eq("TE001",mocte.getTe001())
//                            .eq("TE002",mocte.getTe002())
//                            .eq("TE003",mocte.getTe003()));
//                }//这里就是相当于我人为回调数据库
//                mocteupdateVo.setCode(201);
//                mocteupdateVo.setData(moctCchaDto.getTc001()+"-"+moctCchaDto.getTc002());
//                mocteupdateVo.setMsg("失败：la和ml插入失败了！");
//                resResult.append(mocteupdateVo.getMsg() + " " + mocteupdateVo.getData());
//                continue;
//            }
            mocteupdateVo.setCode(200);
            mocteupdateVo.setData(moctCchaDto.getTc001()+"-"+moctCchaDto.getTc002());
            mocteupdateVo.setMsg("成功：提交了审核，也插入到了la和ml里了！");
            resResult.append("成功。");
//            List<Mocte> mocteList1=mocteMapper.selectList(new QueryWrapper<Mocte>()
//                    .eq("TE001",moctCchaDto.getTc001())
//                    .eq("TE002",moctCchaDto.getTc002()));
        }
        return Result.ok(resResult);
    }

    @Transactional
    public Boolean wmsinsertmocte(List<InitMocte> moctes,String tc008){
        List<WmsInvml> invmlList=new ArrayList<>();
        List<WmsInvla> wmsInvlas=new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();
        // 定义日期时间格式
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
        // 将 LocalDateTime 对象格式化为字符串
        String formattedDateTime = now.format(formatter2);
        boolean result = true;
        for (InitMocte mocte : moctes){
            //库位可以不存在
            if (mocte.getKwInfo() == null || mocte.getKwInfo().isEmpty()) {
                result = insertByKwMocte(now,formattedDateTime,mocte,invmlList,wmsInvlas,tc008);
            } else {
                for (KWAndNum kwAndNum : mocte.getKwInfo()) {
                    mocte.setTe025(kwAndNum.getKw());
                    mocte.setTe005(kwAndNum.getNum());
                    result = insertByKwMocte(now,formattedDateTime,mocte,invmlList,wmsInvlas,tc008);
                    if (!result) return result;
                }
            }
            if (!result) return result;
        }
        return result;
    }

    /**
     * 根据库位插入信息
     */
    private boolean insertByKwMocte(LocalDateTime now,String formattedDateTime, InitMocte mocte, List<WmsInvml> invmlList, List<WmsInvla> wmsInvlas,
                                    String tc008) {
        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyyMMdd");
        String formattedDate = now.format(formatter1);
        WmsInvla wmsInvla1=wmsInvlaMapper.selectOne(new QueryWrapper<WmsInvla>()
                .eq("LA005",-1.0)
                .eq("LA006",mocte.getTe001())//单别
                .eq("LA007",mocte.getTe002())//单号
                .eq("LA008",mocte.getTe003())//序号
                .eq("LA023",mocte.getTe025())//库位
                .eq("LA009",mocte.getTe008())//仓库
                .eq("LA016",mocte.getTe010()));//批号
        if (wmsInvla1 !=null){
            Double t= wmsInvla1.getLa011()-mocte.getTe005() ;
            wmsInvla1.setLa011(t);//把交易明细信息档里的库存量叠加
            int i=wmsInvlaMapper.update(wmsInvla1,new QueryWrapper<WmsInvla>()
                    .eq("LA005",-1.0)
                    .eq("LA006",mocte.getTe001())//单别
                    .eq("LA007",mocte.getTe002())//单号
                    .eq("LA008",mocte.getTe003())//序号
                    .eq("LA023",mocte.getTe025())//库位
                    .eq("LA009",mocte.getTe008())//仓库
                    .eq("LA016",mocte.getTe010()));//批号
            if (i!=1){
                return false;
            }
        }else{
            WmsInvla wmsInvla = new WmsInvla();
            wmsInvla.setCompany(mocte.getCompany());
            wmsInvla.setCreator("ERP");
            wmsInvla.setUsrGroup(mocte.getUsrGroup());
            wmsInvla.setCreateDate(formattedDateTime);
            wmsInvla.setModifier(mocte.getModifier());
            wmsInvla.setModiDate(mocte.getModiDate());
            wmsInvla.setFlag(1.0);
            wmsInvla.setLa001(mocte.getTe004());//品号
            wmsInvla.setLa004(formattedDate);//日期
//            这四位不能重复
            wmsInvla.setLa005(-1.0);//按单据性质的库存影响:减 或 调拨单性质的出写入为-1，其余为+1。
            wmsInvla.setLa006(mocte.getTe001());//单别
            wmsInvla.setLa007(mocte.getTe002());//单号
            wmsInvla.setLa008(mocte.getTe003());//序号
            wmsInvla.setLa009(mocte.getTe008());//仓库
            wmsInvla.setLa010(mocte.getTe014());//备注
            wmsInvla.setLa011(mocte.getTe005());//单据交易库存数量
            wmsInvla.setLa012(0.0);
            wmsInvla.setLa013(0.0);
            wmsInvla.setLa014("3");
            wmsInvla.setLa015("");
            wmsInvla.setLa016(mocte.getTe010());//批号
            wmsInvla.setLa017(0.0);
            wmsInvla.setLa018(0.0);
            wmsInvla.setLa019(0.0);
            wmsInvla.setLa020(0.0);
            wmsInvla.setLa021(0.0);
            wmsInvla.setLa022(formattedDate);//审核时间
            wmsInvla.setLa023(mocte.getTe025());//库位
            wmsInvla.setLa024("");
            wmsInvlas.add(wmsInvla);
            wmsInvlaMapper.insert(wmsInvla);
        }
        WmsInvml wmsInvml = new WmsInvml();
        wmsInvml=wmsInvmlMapper.selectOne(new QueryWrapper<WmsInvml>()
                .eq("ML001",mocte.getTe004())//品号
                .eq("ML002",mocte.getTe008())//仓库
                .eq("ML003",mocte.getTe025())//库位
                .eq("ML004",mocte.getTe010()));//批号
        if (wmsInvml==null){
            wmsInvml = new WmsInvml();
            wmsInvml.setCompany(mocte.getCompany());
            wmsInvml.setCreator("ERP");
            wmsInvml.setUsrGroup(mocte.getUsrGroup());
            wmsInvml.setCreateDate(formattedDateTime);
            wmsInvml.setModifier(mocte.getModifier());
            wmsInvml.setModiDate(mocte.getModiDate());
            wmsInvml.setFlag(1.0);
            wmsInvml.setMl001(mocte.getTe004());//品号
            wmsInvml.setMl002(mocte.getTe008());//仓库
            wmsInvml.setMl003(mocte.getTe025());//库位
            wmsInvml.setMl004(mocte.getTe010());//批号
            wmsInvml.setMl005(mocte.getTe005());//库存数量
            wmsInvml.setMl006(mocte.getTe005());//库存包装数量
            wmsInvml.setMl009(formattedDate);//最近入库日
            int i =wmsInvmlMapper.insert(wmsInvml);
            if (i!=1){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }
        }else {
            invmlList.add(wmsInvml);
            if ("54".equals(tc008) || "55".equals(tc008)){
                Double t= wmsInvml.getMl005()-mocte.getTe005();
                wmsInvml.setMl005(t);//把品号信息档里的库存量减掉领料量
            } else if ("56".equals(tc008) || "57".equals(tc008)) {
                Double t= wmsInvml.getMl005()+mocte.getTe005();
                wmsInvml.setMl005(t);//把品号信息档里的库存量加上退料量
            }
            int i=wmsInvmlMapper.update(wmsInvml,new QueryWrapper<WmsInvml>()
                    .eq("ML001",wmsInvml.getMl001())//品号
                    .eq("ML002",wmsInvml.getMl002())//仓库
                    .eq("ML003",wmsInvml.getMl003())//库位
                    .eq("ML004",wmsInvml.getMl004()));//批号
            if (i!=1){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }
        }

        return true;
    }

    /**
     * 根据库位插入信息
     */
    private boolean insertByKw(LocalDateTime now, String formattedDateTime, LldList mocte, List<WmsInvml> invmlList, List<WmsInvla> wmsInvlas) {
        String lldb =mocte.getLldb();
        String creator =mocte.getCreator();
        String userGroup =mocte.getUserGroup();
        String company =mocte.getCompany();
        WmsInvla wmsInvla1=wmsInvlaMapper.selectOne(new QueryWrapper<WmsInvla>()
                .eq("LA005",-1.0)
                .eq("LA006",mocte.getLldb())//单别
                .eq("LA007",mocte.getLldh())//单号
                .eq("LA008",mocte.getXh())//序号
                .eq("LA023",mocte.getBinCode())//库位
                .eq("LA009",mocte.getWarehouseCode())//仓库
                .eq("LA016",mocte.getLotNumber()));//批号
        if (wmsInvla1 !=null){
            Double t= wmsInvla1.getLa011()-mocte.getQtw() ;
            wmsInvla1.setLa011(t);//把交易明细信息档里的库存量叠加

            int i=wmsInvlaMapper.update(wmsInvla1,new QueryWrapper<WmsInvla>()
                    .eq("LA005",-1.0)
                    .eq("LA006",mocte.getLldb())//单别
                    .eq("LA007",mocte.getLldh())//单号
                    .eq("LA008",mocte.getXh())//序号
                    .eq("LA023",mocte.getBinCode())//库位
                    .eq("LA009",mocte.getWarehouseCode())//仓库
                    .eq("LA016",mocte.getLotNumber()));//批号
            if (i!=1){
                return false;
            }

        }
        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyyMMdd");
        String formattedDate = now.format(formatter1);
        WmsInvml wmsInvml = new WmsInvml();
        WmsInvla wmsInvla = new WmsInvla();
        wmsInvml=wmsInvmlMapper.selectOne(new QueryWrapper<WmsInvml>()
                .eq("ML001",mocte.getWlbh())//品号
                .eq("ML002",mocte.getWarehouseCode())//仓库
                .eq("ML003",mocte.getBinCode())//库位
                .eq("ML004",mocte.getLotNumber()));//批号
        if (wmsInvml==null){
            wmsInvml = new WmsInvml();
            String uuid = UUID.randomUUID().toString();
            wmsInvml.setUdf12(uuid);
            wmsInvml.setCompany(company);
            wmsInvml.setCreator(creator);
            wmsInvml.setUsrGroup(userGroup);
            wmsInvml.setCreateDate(formattedDateTime);
//                wmsInvml.setModifier(mocte.getModifier());
//                wmsInvml.setModiDate(mocte.getModiDate());
            wmsInvml.setFlag(1.0);
            wmsInvml.setMl001(mocte.getWlbh());//品号
            wmsInvml.setMl002(mocte.getWarehouseCode());//仓库
            wmsInvml.setMl003(mocte.getBinCode());//库位
            wmsInvml.setMl004(mocte.getLotNumber());//批号
            wmsInvml.setMl005(mocte.getQtw());//库存数量
            wmsInvml.setMl006(mocte.getQtw());//库存包装数量
            wmsInvml.setMl009(formattedDate);//最近入库日
            int i =wmsInvmlMapper.insert(wmsInvml);
            if (i!=1){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }
        }else {
            invmlList.add(wmsInvml);
            if ("54".equals(lldb) || "55".equals(lldb)){
                Double t= wmsInvml.getMl005()-mocte.getQtw();
                wmsInvml.setMl005(t);//把品号信息档里的库存量减掉领料量
            } else if ("56".equals(lldb) || "57".equals(lldb)) {
                Double t= wmsInvml.getMl005()+mocte.getQtw();
                wmsInvml.setMl005(t);//把品号信息档里的库存量加上退料量
            }
            int i=wmsInvmlMapper.update(wmsInvml,new QueryWrapper<WmsInvml>()
                    .eq("ML001",wmsInvml.getMl001())//品号
                    .eq("ML002",wmsInvml.getMl002())//仓库
                    .eq("ML003",wmsInvml.getMl003())//库位
                    .eq("ML004",wmsInvml.getMl004()));//批号
            if (i!=1){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }
        }
        wmsInvla.setCompany(company);
        wmsInvla.setCreator(creator);
        wmsInvla.setUsrGroup(userGroup);
        wmsInvla.setCreateDate(formattedDateTime);
//            wmsInvla.setModifier(mocte.getModifier());
//            wmsInvla.setModiDate(mocte.getModiDate());
        wmsInvla.setFlag(1.0);
        wmsInvla.setLa001(mocte.getWlbh());//品号
        wmsInvla.setLa004(formattedDate);//日期
//            这四位不能重复
        wmsInvla.setLa005(-1.0);//按单据性质的库存影响:减 或 调拨单性质的出写入为-1，其余为+1。
        wmsInvla.setLa006(mocte.getLldb());//单别
        wmsInvla.setLa007(mocte.getLldh());//单号
        wmsInvla.setLa008(mocte.getXh());//序号
        wmsInvla.setLa009(mocte.getWarehouseCode());//仓库
        wmsInvla.setLa010(mocte.getRemark());//备注
        wmsInvla.setLa011(mocte.getQtw());//单据交易库存数量
        wmsInvla.setLa012(0.0);
        wmsInvla.setLa013(0.0);
        wmsInvla.setLa014("3");
        wmsInvla.setLa015("");
        wmsInvla.setLa016(mocte.getLotNumber());//批号
        wmsInvla.setLa017(0.0);
        wmsInvla.setLa018(0.0);
        wmsInvla.setLa019(0.0);
        wmsInvla.setLa020(0.0);
        wmsInvla.setLa021(0.0);
        wmsInvla.setLa022(formattedDate);//审核时间
        wmsInvla.setLa023(mocte.getBinCode());//库位
        wmsInvla.setLa024("");
        wmsInvlas.add(wmsInvla);
        wmsInvlaMapper.insert(wmsInvla);
        return true;
    }
}
